﻿#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
//反转链表 1.0
///**
// * Definition for singly-linked list.
// * struct ListNode {
// *     int val;
// *     struct ListNode *next;
// * };
// */
//struct ListNode* reverseList(struct ListNode* head) {
//    if (head == NULL) {
//        return NULL;
//    }
//    struct ListNode* n1 = NULL;
//    struct ListNode* n2 = head;
//    struct ListNode* n3 = head->next;
//    while (n2) {
//        n2->next = n1;
//        //迭代
//        n1 = n2;
//        n2 = n3;
//        if (n3 != NULL) {
//            n3 = n3->next;
//        }
//    }
//
//    return n1;
//
//}


//反转链表2.0
///**
// * Definition for singly-linked list.
// * struct ListNode {
// *     int val;
// *     struct ListNode *next;
// * };
// */
//struct ListNode* reverseList(struct ListNode* head) {
//    struct ListNode* cur = head;
//    struct ListNode* rhead = NULL;
//    while (cur) {
//        struct ListNode* next = cur->next;
//        //头插
//        cur->next = rhead;
//        rhead = cur;
//
//        cur = next;
//    }
//
//    return rhead;
//}


//倒数第K个节点
///**
// * struct ListNode {
// *	int val;
// *	struct ListNode *next;
// * };
// */
// /**
//  * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
//  *
//  *
//  * @param pHead ListNode类
//  * @param k int整型
//  * @return ListNode类
//  */
//struct ListNode* FindKthToTail(struct ListNode* pHead, int k) {
//    struct ListNode* fast = pHead;
//    struct ListNode* slow = pHead;
//    while (k) {
//        if (fast == NULL) {
//            return NULL;
//        }
//        fast = fast->next;
//        k--;
//    }
//    while (fast) {
//        fast = fast->next;
//        slow = slow->next;
//    }
//    return slow;
//    // write code here
//}


//找中间元素
///**
// * Definition for singly-linked list.
// * struct ListNode {
// *     int val;
// *     struct ListNode *next;
// * };
// */
//struct ListNode* middleNode(struct ListNode* head) {
//	struct ListNode* slow = head;
//	struct ListNode* fast = head;
//	while (fast && fast->next) {
//		slow = slow->next;
//		fast = fast->next->next;
//	}//fast 的速度是slow的两倍 所以slow在中间的时候，fast在最后
//
//	return slow;
//}


// 编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结点之前 
///*
//struct ListNode {
//	int val;
//	struct ListNode *next;
//	ListNode(int x) : val(x), next(NULL) {}
//};*/
//class Partition {
//public:
//	ListNode* partition(ListNode* pHead, int x) {
//		// write code here
//		ListNode* lesshead, * lesstail, * greaterhead, * greatertail;
//		lesshead = lesstail = (ListNode*)malloc(sizeof(ListNode));
//		greaterhead = greatertail = (ListNode*)malloc(sizeof(ListNode));
//		ListNode* cur = pHead;
//		while (cur) {
//			if (cur->val < x) {
//				lesstail->next = cur;
//				lesstail = lesstail->next;
//			}
//			else {
//				greatertail->next = cur;
//				greatertail = greatertail->next;
//			}
//			cur = cur->next;
//		}
//		lesstail->next = greaterhead->next;
//		greatertail->next = NULL;
//		pHead = lesshead->next;
//		free(lesshead);
//		free(greaterhead);
//		return pHead;
//	}
//};



//链表的回文结构
///*
//struct ListNode {
//	int val;
//	struct ListNode *next;
//	ListNode(int x) : val(x), next(NULL) {}
//};*/
//ListNode* midd(ListNode* head) {
//	ListNode* slow = head;
//	ListNode* fast = head;
//	while (fast && fast->next) {
//		slow = slow->next;
//		fast = fast->next->next;
//	}
//	return slow;
//}
//
//ListNode* reverse(ListNode* head) {
//	ListNode* cur = head;
//	ListNode* rhead = NULL;
//	while (cur) {
//		ListNode* next = cur->next;
//		cur->next = rhead;
//		rhead = cur;
//		cur = next;
//	}
//	return rhead;
//}
//class PalindromeList {
//public:
//	bool chkPalindrome(ListNode* head) {
//		ListNode* mid = midd(head);
//		ListNode* rhead = reverse(mid);
//		ListNode* cur = rhead;
//		while (cur) {
//			if (cur->val != head->val) {
//				return false;
//			}
//			else {
//				cur = cur->next;
//				head = head->next;
//			}
//
//		}
//		return true;
//
//	}
//};



// 输入两个链表，找出它们的第一个公共结点
///**
// * Definition for singly-linked list.
// * struct ListNode {
// *     int val;
// *     struct ListNode *next;
// * };
// */
//struct ListNode* getIntersectionNode(struct ListNode* headA, struct ListNode* headB) {
//	struct ListNode* tailA = headA;
//	struct ListNode* tailB = headB;
//	int lenA = 1, lenB = 1;
//	while (tailA->next) {
//		tailA = tailA->next;
//		lenA++;
//	}
//	while (tailB->next) {
//		tailB = tailB->next;
//		lenB++;
//	}
//	if (tailA != tailB) {
//		return NULL;
//	}
//
//	int gap = abs(lenA - lenB);
//	struct ListNode* longlist = headA;
//	struct ListNode* shortlist = headB;
//	if (lenA < lenB) {
//		longlist = headB;
//		shortlist = headA;
//	}
//
//	while (gap--) {
//		longlist = longlist->next;
//	}
//	while (longlist != shortlist) {
//		longlist = longlist->next;
//		shortlist = shortlist->next;
//	}
//
//	return longlist;
//
//
//}


//判断环形链表
///**
// * Definition for singly-linked list.
// * struct ListNode {
// *     int val;
// *     struct ListNode *next;
// * };
// */
//slow一次走一步
//fast一次走两步
//1、slow和fast一定会相遇
//fast会先进环，slow会后进环，假设slow进环时，slow和fast之间的距离为N
//slow进环以后，fast开始追击slow，slow每走1步，fast每走2步，他们之间距离缩小1.
// 
// 
//slow一次走一步
//fast一次走三步
//1、slow和fast一定会相遇吗 ? 不一定
//fast会先进环，slow会后进环，假设slow进环时，slow和fast之间的距离为N
//slow进环以后，fast开始追击slow，slow每走1步，fast每走3步，他们之间距离缩小2
//偶数可以追上，奇数再讨论
//进入新一轮的追击
//slow和fast的距离变成C-1(假设C是环的长度)
//如果C-1是偶数那么下一轮可以追上
//如果C-1是奇数那么永远追不上
//bool hasCycle(struct ListNode* head) {
//	struct ListNode* fast = head, * slow = head;
//	while (fast && fast->next) {
//		fast = fast->next->next;
//		slow = slow->next;
//		if (slow == fast) {
//			return true;
//		}
//	}
//	return false;
//
//}


//给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 NULL
///**
//一个指针从相遇点走，一个指针从链表头开始走，他们会在入口点相遇
//链表头--环入口点距离:L
//环入口点--相遇点距离 : X
//环的长度 : C
//slow走的路程是多少 : L + X
//fast走的路程是多少 : L + n * C + X
//假设n是slow进环前，fast在环里面转的圈数
// * Definition for singly-linked list.
// * struct ListNode {
// *     int val;
// *     struct ListNode *next;
// * };
// */
//struct ListNode* detectCycle(struct ListNode* head) {
//	struct ListNode* slow = head, * fast = head;
//	while (fast && fast->next) {
//		slow = slow->next;
//		fast = fast->next->next;
//		if (slow == fast) {
//			struct ListNode* meet = slow;
//			while (meet != head) {
//				meet = meet->next;
//				head = head->next;
//			}
//			return meet;
//		}
//	}
//	return NULL;
//}





//约瑟夫环
struct Josephus {
	int data;
	struct Josephus* next;
};

struct Josephus* Buynode(int x) {
	struct Josephus* newnode = (struct Josephus*)malloc(sizeof(struct Josephus));
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}
void JosephusPushFront(struct Josephus** pphead,int x) {
	assert(pphead);
	struct Josephus* newnode = Buynode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}
void JosephusPrint(struct Josephus* phead) {
	struct Josephus* cur = phead;
	int n = 10;
	while (n--) {
		printf("%d->", cur->data);
		cur = cur->next;
	}
	//printf("NULL\n");
}
struct Josephus* JosephusFind(struct Josephus* phead, int x) {
	//assert(phead);
	struct Josephus* cur = phead;
	while (cur) {
		if (cur->data == x) {
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}
int main() {
	struct Josephus* plist = NULL;
	// 9 1 5
	int n = 0, s = 0, m = 0;
	scanf("%d %d %d", &n, &s, &m);
	//创建n个节点
	int nn = n;
	while(nn) {
		JosephusPushFront(&plist, nn);
		nn--;
	}
	//JosephusPrint(plist);   //plist==1
	//创建循环链表
	struct Josephus* Circle = JosephusFind(plist, n);
	Circle->next = plist;
	//找到头节点
	struct Josephus* begin = JosephusFind(plist, s);
	struct Josephus* p = begin;
	struct Josephus* r = NULL;
	//JosephusPrint(p); 
	//打印结果  5 1 7 4 3 6 9 2 8      1 3 6 2 9 5 7 4 8
	while (p->next != p) {//p->next == p  p只剩一个元素
		for (int i = 1; i < m; i++) {
			r = p;
			p = p->next;
		    //p此时是待删除的元素
		}
		printf("%d ", p->data);
		//删除p
		r->next = p->next;
		struct Josephus* del = p;
		p = p->next;
		free(del);//free 之后指针不能用了 所以用tmp保存p 更新p之后free掉tmp

	}
	printf("%d ", p->data);
	begin=plist = NULL;
	free(p);
	return 0;
}